vulkan: Split renderpass op into 2

Add an explicit begin() and an end() op. For now, this looks like
overkill, but it allows doing renderpasses with custom ops that are not
meant to render a rendernode.

Examples for this are pre/postprocessing passes or 2-pass blur.

vulkan: Don't store the renderpass

It's only used when parsing.

vulkan: Pass rectangles where no regions are used

The API was using regions because it always had. But all the code ever
did was get the extents of the region.

So simplify everything by using rectangles everywhere.

vulkan: Stop keeping the context around

These days, we can query it with gsk_vulkan_render_get_context().

Makes quite a few functions require one less argument.
And it also makes the GskVulkanRenderPass empty. Gotta figure out what
to do with it.

vulkan: Remove unused stuff fom renderpass

... and move it to the one place where it is used.

vulkan: Free storage buffer when disposing render object

This caused a lot of leaked memory on the GPU when rendering textures.
(Read: inside node-editor)

vulkan: Fix leaks with pipeline cache

In particular, we were leaking the actual cache and then created a new
one.

build: Move the glslc check into the top meson file

Put it with the other Vulkan checks, so it's easy to find.

vulkan: Remove the pre-compiled shaders

Instead, build-depnd on glslc to build them.

glslc is available in all important distros for a while:
  Fedora >= 28
  Ubuntu >= 23.04
  Debian >= 12
  Arch
  Opensuse >= 15.2
  msys2
are the ones I checked.

So we can depend on it and avoid having to deal with keeping spirv files
up-to-date in all commits.

It's also 700kB of data, and not updating it helps.

ci: Include glslc for Vulkan builds

Merge branch 'wip/otte/vulkan-for-main' into 'main'

vulkan: Make RenderOps into proper structs

See merge request GNOME/gtk!6188

vulkan: Rebuild the shaders

Just to be sure I didn't forget rebuilding some shader at some point.

vulkan: Redo barriers

We now store all the relevant state of the image inside the VulkanImage
struct, so we can delay barriers for as long as possible.

Whenever we want to use an image, we call the new
gsk_vulkan_image_transition() and it will add a barrier to the desired
state if one is necessary.

vulkan: Track the current pipeline stage of images

This way, we can in theory properly transition images because we know
which stage to transition from.

IN practice this is happening in future commits.

vulkan: Handle images in the ShaderOp

This looks more convoluted in this commit, but future commits will
hopefully make up for it.

vulkan: Make clip type an enum

and add gsk_vulkan_shader_op_alloc() that sets it properly.

vulkan: Introduce GskVulkanShaderOp

It's the new base class for shaders now.

We're doing deep inheritance now, woohoo!

Also, port all the shader ops to it.

vulkan: Remove GskVulkanUploader

... and all the remaining functions still using it.

It's all unused and has been replaced by upload and download ops.

With this change, all GPU operations now go via GskVulkanOp.command()
and no more side channels exist.

vulkan: Add GskVulkanDownloadOp

This op queues a download of an image. The image will only be available
once the commands finished executing, so it requires waiting for the
render to finish, which makes the API a bit awkward.

Included is also a download_png_op() useful for debugging.

vulkan: Properly update image layouts

The render pass ops were not updating the image's layout to the final
layout when a render pass ends.

Fix that.

Also make the layouts explicit arguments to the render pass op.

vulkan: Simplify render API

Merge reset() and draw() into a single render() function.

Also clean up some naming on the way.

vulkan: Remove the VulkanOp.upload() vfunc

It's not used anymore.

vulkan: Add an UploadGlyphOp

Now all the uploads have their own op.

vulkan: Split out a function

Split out the function that uploads using a buffer, so that it can be
used with an area to only update parts of the image.

That feature is not used yet, but will be in future commits.

vulkan: Remove unused functions

vulkan: Merge the two upload ops

Now they both use the same upload code.

vulkan: Merge te 2 upload ops

They are about to share a ton of code, sothey should be in the same
source file.

This commit just does the copying, no functional changes.

vulkan: Fold functions into only caller

Now that the VulkanOp does begin/end of render passes, there's no need
to have a renderpass function for it anymore.

tests: Reduce number of random fonts

We were clowing through all the Pango caches for no benefit.

It made the test generation stuck in fontconfig loops instead of
quickly generating tests.

So don't do that and limit the different fonts to some reasonable list
of options.

vulkan: Don't merge too many drawing commands

If a command takes too long to execute, Vulkan drivers will think they
are inflooping and abort what they were doing.

For the simple color shader with smallish nodes, this happens around
10M instances, as tested with the output of
  ./tests/rendernode-create-tests 10000000 colors.node

So just limit it to way lower, so that we barely never hit it, ut still
pick a big number so this optimization stays noticable.

vulkan: Simplify

The renderpassop always has a matching end op, so there is no need to
check for the end of operations and emit one manually.

vulkan: Merge function into only caller

The renderpass reshuffling means we can move a bunch of functions now.

This is one of them.

vulkan: Don't try that hard to use clear

For small regions, the optimization doesn't matter that much, so we
don't need to do lots of work on the CPU.

In particular, this should catch icons and their backgrounds (32x32),
but I was generous in selecting the number.

Gets my discrete AMD on widget-factory back to the 1900fps it had before
this optimization while making the driver clock the GPU's shader at
1.7GHz instead of the 2.1GHz it used before.

vulkan: Try really hard to use clear

Using clear avoids the shader engine (see last commit), so if we can get
pixels out of it, we should.

So we detect the overlap with the rounded corners of the clip region and
emit shaders for those, but then use Clear() for the rest.

With this in place, widget-factory on my integrated Intel TigerLake gets
a 60% performance boost.

vulkan: Add a clear op

The op emits a vkCmdClearAttachments() with a given color. That can be
used with color nodes that are pixel-aligned and opaque to significantly
speed up rendering when the window background is a solid color.

However, currently this fails a bit outside of fullscreen when rounded
clip rectangles are in use to draw rounded corners.

vulkan: Adapt a function

I want to use it for more operations when we can break those down to
operations on the pixels directly, and this function is what's needed
for that.

vulkan: Implement direct upload for the cairo op

vulkan: Upload cairo images "directly"

Instead of using the upload vfunc and going via the code in
GskVulkanImage, copy/paste the relevant code into the command() vfunc.

This is meant to achieve multiple things:
1. Get rid of GskVulkanUploader and its own command buffer and general
   non-integration with operations.
2. Get rid of GskVulkanOp:upload()
3. Get the upload/download code machinery for GskVulkanImage and put it
   with the actual operations.

The current code can't do direct upload/download, that will follow in a
future commit.

vulkan: Split out a function

This is refactoring for future changes.

vulkan: Emit a renderpass op

... instead of doing the equivalent things manually by creating a
RenderPass and calling the relevant functions.

Now all renderpass operations are indeed stored in ops.

Also reshuffle the command emission code, because we no longer need to
emit the ops for the base renderpass.

As a result we only submit a single command buffer containing all the
render passes instead of once per render pass.
We also bind vertex buffers and descriptor sets only once now at the
start instead of once per renderpass.

vulkan: Sort the ops

Use the OpClass.stage to order operations:

1. Put upload ops first
   This way we can ensure they are executed first.
2. Move subpasses for offscreens in front of the pass using them.

vulkan: Store a pointer to the first op

This is not yet useful, but will be soon.

vulkan: Indent verbose prints again

This feature was lost when refactoring, restore it.

vulkan: Rename offscreenp to renderpassop

They should be used for all renderpasses, not just offscreens.

vulkan: Move the render ops to the Render

This is a massive refactoring because it collects all the renderops
of all renderpasses into one long array in the Render object.

Lots of code in there is still flaky and needs cleanup. That will
follow in further commits.

Other than that it does work fine though.

vulkan: Batch together multiple draw calls

If multiple instances of the same op appear in order, we can emit one
vkCmdDraw() for all of them together.

So do that.

vulkan: Unify some functions

All the ops that just execute a shader do pretty much the same stuff, so
put it all in a single function that they all call.

It's basically faking a base class for them.

vulkan: Make Op->command() return the next op

This way, ops can batch themselves.

They don't dothat yet, but you know where this is going...

vulkan: Add a Stage enum

It's declaring at which stage this command should run. So far nothing is
using it, but that will follow in future commits.

vulkan: Bind descriptor sets early

Simplfies the code and doesn't change anything.

vulkan: Remove unused arguments from Op vfuncs

Makes code a lot simpler.

vulkan: Cache VkRenderPasses in render object

Instead of recreating the same renderpass object in every frame and for
every offscreen, just reuse it.

Technically, we can save this per-renderer or even per-display (it
should really be cached by VkDevice), but we have no infrastructure for
that.

vulkan: Rename function

The function name gsk_vulkan_render_get_pipeline() had been used for
GskVulkanPipeline. Since those are gone now, we can use that name for
VkPipelines.

vulkan: Cache framebuffer in image

Instead of recreating them every frame for every render pass, reuse the
same framebuffer.

vulkan: Put the vertex buffer into the render object

Renderpasses get recreated every frame, but we keep render objects
around. So if we keep the vertex buffer in the render object, we can
also keep it around and just reuse it.

Also, we only need one buffer for all the render passes, which is
another bonus.

The initial buffer size is chosen at 128kB. Maximized Nautilus,
gnome-text-editor with an open file and widget-factory take ~100kB when
doing a full redraw. Other apps are between 30-50kB usually.

So I chose a value that is not too big, but catches ~90% of cases.

vulkan: Add an offscreen end op

This is basically a fancy no-op for now, but reordering of ops will need
it to indicate end of offscreen commands.

vulkan: Don't intern strings

Interning strings is slow, especially if we can instead do direct
pointer compares.

Also refactor the pipeline lookup code a bit to make use of the
refactored code.

vulkan: Add VulkanOp->next

Set it after creating all the ops and then use it for iterating.

Note that we cannot set it while creating the ops because the array may
be realloc()ed into a different memory region which would invalidate all
the pointers.

It currently has no use, but that will come later.

Also put the typedefs into headers in gsk/vulkan, they have nthing to do
outside that directory.

vulkan: Remove all the semaphores

They aren't necessary with just one queue.

vulkan: Remove unused stuff from render object

Neither cleanup images nor multiple renderpasses are used anymore since
both of those are now handled inside the render ops.

vulkan: Pass the node when setting up

Remove the function to add a node from both the GskVulkanRender and the
GskVulkanRenderPass.

That means they are both now meant to draw exactly one node.

vulkan: Add infrastructure for printing ops

... and add a GSK_DEBUG=verbose setting making use of it.

vulkan: Repurpose mask shader

Use if for mask nodes to do the generic source image + mask image
operation with the 4 available mask modes.

vulkan: Remove op.get_pipeline()

It's unused now that GskVulkanPipeline is gone.

vulkan: Remove GskVulkanPipeline

Pipelines are handled differently now.

vulkan: Add gskvulkanprivate.h

It's the new place for all the common stuff.

Because the old place is about to go away.

vulkan: Turn push constants into an op

This removes the last remaining original op from the gskvulkanrenderpass.c,
so that file got some cleanup, too.

vulkan: Make glyphs use new node ops

This is a rudimentary - but working - port.
Glyph uploads are still using the old machinery, a bunch of functions
still exist that probably aren't necessary anymore and each glyph emits
its own node.

This will need to be improved in further commits.

vulkan: Add a glyph shader

This shader is an updated version of the mask shader, but I want to use
the mask name for the mask node and that's a different functionality.

Also, add an operation for it and partially implement the mask node
using it, so we can test that this shader works.

Replacing the shader used for text rendering is the next step.

vulkan: Remove hacky function arguments

They're unused now that we removed the old render ops.

vulkan: Port linear gradient to new ops

This was the last user of GskVulkanOpRender, so delete that one, too.

vulkan: Make border shader use new ops

vulkan: Add a blur op and use it

This removes the last old user of offscreens, so those functions are now
gone, too.

vulkan: Port inset and outset shadow to new ops

vulkan: Port blend mode to new ops

vulkan: Add cross-fade op

The benefit here is that we can now properly cross-fade when one of
start/end is fully clipped out by just replacing it with an opacity op
for the other.

This was not possible with the old way we did things.

vulkan: Factor out call to opacity op

I want to reuse it for crossfades (see next commit).

vulkan: Convert color op to new method

This is a straightforward and simple port.

vulkan: Create pipeline differently for ops

Instead of creating a pipeline GObject, just ask for the VkPipeline.

And instead of having the Op handle it, just let the renderpass look
up/create the relevant pipeline while creating commands so that it can
insert vkCmdBindPipeline calls as-needed.

Revert "vulkan: Always render clip extents"

This reverts commit 0f184d3270cfac522a05ae06d28cc2f1e32c0e6d.

The renderer is good enough to make use of the clip region.

Or rather: If it isn't, the renderpass should take care of that, not the
render object.

vulkan: Combine textures and samplers again

This reverts most of commit f420c143e0d8947a433704969bab02aea47d82f5
again because it turns out GPUs like combined images and samplers.

But: The one thing we don't revert is allowing the C code to select any
combination of sampler and image:
gsk_vulkan_render_get_image_descriptor() now takes a 2nd argument
specifying the sampler.

This allows the same flexibility as before, we just combine things
early.

This change was inspired by
https://developer.nvidia.com/blog/vulkan-dos-donts/

vulkan: Store shaders in the display

Have a resource path => vkShaderModule hash table instead of doing fancy
custom objects.

A benefit is that shader modules are now shared between all renderers
and pipelines.

vulkan: Initialize ops differently

Instead of creating the op manually, just pass in the renderpass and
have the op created from there.

This way ops aren't really initialized anymore, they are more appended
to the queue, so instead of foo_op_init() we can just call the function
foo_op().

vulkan: Use VkPipeline instead of GskVulkanPipeline

This is in preparation for getting rid of GskVulkanPipelines.

vulkan: Use new ops for repeat nodes

The new code always uses an offscreen, even for children that are
exactly fitting texture nodes.
I would have had to write more code and didn't consider it worth it,
especially because it would have required complicating the
get_as_image() function.

This was the last node using the texture pipeline.

vulkan: Implement fallback using new nodes

With Cairo upload and texture nodes being available, we can do that now.

vulkan: Pass bounds to texture op

This way the node can do the normalization (and maybe stop doing it
in the future).

vulkan: Add a Cairo upload node

... and use it for cairo nodes.

vulkan: Port opacity to new ops

vulkan: Add offscreen and color-matrix op

.. and use them for color-matrix operations.

vulkan: Split out a function

We'll need it elsewhere soon.

vulkan: Add an argument to vfunc

We need this in the future.

vulkan: Remove nonexisting function from header

vulkan: Split out a function

Making that function externally usable allows having render passes
managed externally.

Also remove a nonexisting function from the header.

vulkan: Use new ops for TextureScale nodes

vulkan: Add new renderops for texture rendering

Adds 2 ops:

- Upload
  Creates a new Vulkan image and uploads data into it

- Texture
  Draws a given image

These 2 ops are then used for GskTextureNodes.

vulkan: Split texture caching code

Instead of having one function that gets the image for the texture and
uploads it if it doesn't exist yet, make it 2 functions:

One to get the texture if it exists.
One to assign an uploaded image to the texture.

This way, we can potentially do the upload ourselves.

vulkan: Actually run the op_finish()

It's a no-op for all current ops, so it isn't really necessary. But
that's about to change.

vulkan: Pass context, not uploader

We don't need the uploader when creating the image, only when uploading.

vulkan: Create the first real VulkanOp

Split out the scissor op into its own implementation as a proof of
concept of how ops are meant to look when they are actually working.